home *** CD-ROM | disk | FTP | other *** search
/ Disc to the Future 2 / Disc to the Future Part II Programmer's Reference (Wayzata Technology)(6013)(1992).bin / MAC / THINKC / 4_0 / MACUNZIP / UNZIP.C < prev    next >
Text File  |  1991-08-16  |  42KB  |  1,693 lines
  1. /*
  2.  
  3. UnZip for the Macintosh
  4.  
  5. John Eng    July 1991
  6.  
  7. Based on the TURBO C Version 2.0.1 for the IBM by Samuel H. Smith as
  8. modified by George M. Sipe for "portability" to UNIX, Microsoft C for
  9. the IBM, and other machines.
  10.  
  11. This program unpacks .ZIP files, a packing format that is used on IBM
  12. systems.  On non-IBM systems, this program may be used to unpack text
  13. files and certain standard data (e.g., MIDI) files.
  14.  
  15. Several modifications of the "portable" Smith/Sipe source code were
  16. necessary to enable compilation on a Macintosh with the Lightspeed C
  17. v2.01 compiler.  All modifications for the Macintosh are initialled
  18. "J.E." with explanations in this source file; nothing from the original
  19. Smith/Sipe source file was deleted.  Two additional files, MacUnZip.h
  20. and MacUnZip.c, were created to compensate for non-portable code,
  21. libraries, and header files in the Smith/Sipe source as well as for
  22. idiosyncrasies and bugs of Lightspeed C v2.01. The latter may not be
  23. present in more recent versions of Lightspeed C.  I have minimized my
  24. modifications to the code and have hopefully enhanced its portability.
  25.  
  26. Please include these comments when uploading onto other computer
  27. services to assist any subsequent efforts to port this code.  */
  28.  
  29. #include "MacUnZip.h"    /* J.E., Special header file for the Macintosh */
  30.  
  31. /*
  32.  * Copyright 1989 Samuel H. Smith;  All rights reserved
  33.  *
  34.  * Do not distribute modified versions without my permission.
  35.  * Do not remove or alter this notice or any other copyright notice.
  36.  * If you use this in your own program you must distribute source code.
  37.  * Do not use any of this in a commercial product.
  38.  *
  39.  */
  40.  
  41. /*
  42.  * UnZip - A simple zipfile extract utility
  43.  *
  44.  * To compile:
  45.  *      tcc -B -O -Z -G -mc unzip.c    ;turbo C 2.0, compact model
  46.  *    cl /O /AC /G0 /W3 -c unzip.    ;msc 5.1, compact model
  47.  *    cc -O -DOLDC -Dunix {-DHIGH_LOW} {-DSHORTC} -c unzip.c    ;unix pcc
  48.  *
  49.  * Port to Unix and MSC (i.e. "portable version") by George M. Sipe
  50.  * (rebel!george).
  51.  *
  52.  */
  53.  
  54. #define VERSION  \
  55.     "UnZip:  Zipfile Extract v2.0.1 of 09-16-89;  (C) 1989 Samuel H. Smith"
  56.  
  57. #ifdef    SHORTC
  58. #define    compressed_size        cmpr_sz
  59. #define    extract_zipfile        ext_zip
  60. #define    filename        fn
  61. #define    follower        flwr
  62. #define    hsize_array_byte    hsz_a_byte
  63. #define    last_mod_file_date    mod_fdate
  64. #define    lit_tree_present    lt_present
  65. #define    maxcodemax        mx_cd_mx
  66. #define    number_disk_with_start_central_directory ndwsc
  67. #define    process_central_file_header pcfhdr
  68. #define    process_end_central_dir    pecdir
  69. #define    process_headers        proc_hdrs
  70. #define    total_entries_central_dir tecdir
  71. #define    version_made_by        v_made_by
  72. #define    LoadTrees        LdTrees
  73. #endif    /* SHORTC */
  74.  
  75. typedef unsigned char byte;    /* code assumes UNSIGNED bytes */
  76. typedef long longint;        /* sizeof must be 4 bytes */
  77. typedef unsigned short word;    /* sizeof must be 2 bytes */
  78. typedef char boolean;
  79.  
  80. #define STRSIZ 256
  81.  
  82. #include <stdio.h>
  83.  /* this is your standard header for all C compiles */
  84.  
  85. #ifndef    OLDC
  86. #include <stdlib.h>
  87.  /* this include defines various standard library prototypes */
  88. #define    VOIDARG    void        /* function definitions support (void) */
  89. #else
  90. #include <ctype.h>
  91. #define    VOIDARG            /* function definitions support () only */
  92. #endif    /* OLDC */
  93.  
  94.  
  95. /*
  96.  * SEE HOST OPERATING SYSTEM SPECIFICS SECTION STARTING NEAR LINE 180
  97.  *
  98.  */
  99.  
  100.  
  101. /* ----------------------------------------------------------- */
  102. /*
  103.  * Zipfile layout declarations
  104.  *
  105.  */
  106.  
  107. typedef longint signature_type;
  108.  
  109.  
  110. #define LOCAL_FILE_HEADER_SIGNATURE  0x04034b50L
  111.  
  112.  
  113. typedef struct local_file_header {
  114.     word version_needed_to_extract;
  115.         word general_purpose_bit_flag;
  116.     word compression_method;
  117.     word last_mod_file_time;
  118.     word last_mod_file_date;
  119.     longint crc32;
  120.     longint compressed_size;
  121.         longint uncompressed_size;
  122.     word filename_length;
  123.     word extra_field_length;
  124. } local_file_header;
  125.  
  126.  
  127. #define CENTRAL_FILE_HEADER_SIGNATURE  0x02014b50L
  128.  
  129.  
  130. typedef struct central_directory_file_header {
  131.     word version_made_by;
  132.     word version_needed_to_extract;
  133.     word general_purpose_bit_flag;
  134.     word compression_method;
  135.     word last_mod_file_time;
  136.     word last_mod_file_date;
  137.     longint crc32;
  138.     longint compressed_size;
  139.     longint uncompressed_size;
  140.     word filename_length;
  141.     word extra_field_length;
  142.     word file_comment_length;
  143.     word disk_number_start;
  144.     word internal_file_attributes;
  145.     longint external_file_attributes;
  146.     longint relative_offset_local_header;
  147. } central_directory_file_header;
  148.  
  149.  
  150. #define END_CENTRAL_DIR_SIGNATURE  0x06054b50L
  151.  
  152.  
  153. typedef struct end_central_dir_record {
  154.     word number_this_disk;
  155. #ifndef    TURBOC
  156.     word num_disk_with_start_cent_dir;
  157.     word tot_ents_cent_dir_on_this_disk;
  158. #else
  159.     word number_disk_with_start_central_directory;
  160.     word total_entries_central_dir_on_this_disk;
  161. #endif    /* TURBOC */
  162.     word total_entries_central_dir;
  163.     longint size_central_directory;
  164.     longint offset_start_central_directory;
  165.     word zipfile_comment_length;
  166. } end_central_dir_record;
  167.  
  168.  
  169.  
  170. /* ----------------------------------------------------------- */
  171. /*
  172.  * input file variables
  173.  *
  174.  */
  175.  
  176. #define INBUFSIZ 0x2000
  177. byte *inbuf;            /* input file buffer - any size is legal */
  178. byte *inptr;
  179.  
  180. int incnt;
  181. unsigned bitbuf;
  182. int bits_left;
  183. boolean zipeof;
  184.  
  185. int zipfd;
  186. char zipfn[STRSIZ];
  187. local_file_header lrec;
  188.  
  189. #ifdef    HIGH_LOW
  190. int w0, w1;            /* word translation indices */
  191. int li0, li1, li2, li3;        /* long int translation indices */
  192. #endif    /* HIGH_LOW */
  193.  
  194.  
  195. /* ----------------------------------------------------------- */
  196. /*
  197.  * output stream variables
  198.  *
  199.  */
  200.  
  201. #define OUTBUFSIZ 0x2000        /* must be 0x2000 or larger for unImplode */
  202. byte *outbuf;                   /* buffer for rle look-back */
  203. byte *outptr;
  204.  
  205. longint outpos;            /* absolute position in outfile */
  206. int outcnt;            /* current position in outbuf */
  207.  
  208. int outfd;
  209. char filename[STRSIZ];
  210. char extra[STRSIZ];
  211.  
  212. #define DLE 144
  213.  
  214.  
  215. /* ----------------------------------------------------------- */
  216. /*
  217.  * shrink/reduce working storage
  218.  *
  219.  */
  220.  
  221. int factor;
  222. byte followers[256][64];
  223. byte Slen[256];
  224.  
  225. #define max_bits 13
  226. #define init_bits 9
  227. #define hsize 8192
  228. #define first_ent 257
  229. #define clear 256
  230.  
  231. typedef int hsize_array_integer[hsize+1];
  232. typedef byte hsize_array_byte[hsize+1];
  233.  
  234. /*hsize_array_integer prefix_of;*/    /* J.E., See "MacUnZip.h" */
  235. /*hsize_array_byte suffix_of;*/       /* J.E. */
  236. /*hsize_array_byte stack;*/           /* J.E. */
  237.  
  238. int codesize;
  239. int maxcode;
  240. int free_ent;
  241. int maxcodemax;
  242. int offset;
  243. int sizex;
  244.  
  245.  
  246.  
  247. /* ============================================================= */
  248. /*
  249.  * Host operating system details
  250.  *
  251.  */
  252.  
  253. /*#include <string.h>*/    /* J.E., Non-portable header file */
  254. #include <strings.h>       /* J.E. */
  255.  /* this include defines strcpy, strcmp, etc. */
  256.  
  257. #ifndef    TURBOC
  258. /*#include <sys/types.h>*/     /* J.E., Non-portable header file */
  259. #include <types.h>             /* J.E. */
  260.  /*
  261.   * this include file defines
  262.   *        dev_t (* device type *)
  263.   * as used in the sys/utime.h and sys/stat.h header files below
  264.   */
  265.  
  266. #ifndef    OLDC
  267. #include <sys/utime.h>
  268.  /*
  269.   * this include file defines
  270.   *        struct utimbuf (* utime buffer structure *)
  271.   *        utime()        (* utime function *)
  272.   * as used in the set_file_time() function defined below
  273.   */
  274. #endif    /* !OLDC */
  275. #endif    /* !TURBOC */
  276.  
  277. #ifndef    TURBOC
  278. #include <time.h>
  279. struct ftime {
  280.     unsigned ft_tsec: 5;    /* two seconds */
  281.     unsigned ft_min: 6;    /* minutes */
  282.     unsigned ft_hour: 5;    /* hours */
  283.     unsigned ft_day: 5;    /* days */
  284.     unsigned ft_month: 4;    /* months */
  285.     unsigned ft_year: 7;    /* years  - 1980 */
  286. };
  287. #endif    /* TURBOC */
  288. #ifndef    OLDC
  289. #include <io.h>
  290. #else
  291. /*#include <sys/file.h>*/    /* J.E., Non-portable header file */
  292. #ifdef    L_SET
  293. #define    SEEK_SET    L_SET
  294. #else
  295. #define    SEEK_SET    0
  296. #endif    /* L_SET */
  297. #endif    /* OLDC */
  298.  /*
  299.   * this include file defines
  300.   *             struct ftime ...        (* file time/date stamp info *)
  301.   *             int setftime (int handle, struct ftime *ftimep);
  302.   *             #define SEEK_CUR  1     (* lseek() modes *)
  303.   *             #define SEEK_END  2
  304.   *             #define SEEK_SET  0
  305.   */
  306.  
  307. /*#include <fcntl.h>*/    /* J.E., Non-portable header file */
  308. #ifndef    O_BINARY
  309. #define    O_BINARY    0
  310. #endif    /* O_BINARY */
  311.  /*
  312.   * this include file defines
  313.   *             #define O_BINARY 0x8000  (* no cr-lf translation *)
  314.   * as used in the open() standard function
  315.   */
  316.  
  317. /*#include <sys/stat.h>*/    /* J.E., Non-portable header file */
  318.  /*
  319.   * this include file defines
  320.   *             #define S_IREAD 0x0100  (* owner may read *)
  321.   *             #define S_IWRITE 0x0080 (* owner may write *)
  322.   * as used in the creat() standard function
  323.   */
  324.  
  325. /* #undef HIGH_LOW - define externally */
  326.  /*
  327.   * change 'undef' to 'define' if your machine stores high order bytes in
  328.   * lower addresses.
  329.   */
  330.  
  331. void set_file_time(VOIDARG)
  332.  /*
  333.   * set the output file date/time stamp according to information from the
  334.   * zipfile directory record for this file 
  335.   */
  336. {
  337.     union {
  338.                 struct ftime ft;        /* system file time record */
  339.         struct {
  340.                         word ztime;     /* date and time words */
  341.                         word zdate;     /* .. same format as in .ZIP file */
  342.         } zt;
  343.     } td;
  344.  
  345.     /*
  346.      * set output file date and time - this is optional and can be
  347.      * deleted if your compiler does not easily support setftime() 
  348.      */
  349. #ifdef    TURBOC
  350.     td.zt.ztime = lrec.last_mod_file_time;
  351.     td.zt.zdate = lrec.last_mod_file_date;
  352.  
  353.     setftime(outfd, &td.ft);
  354. #else
  355.  
  356. #define leap(y)     (((y) % 4 == 0 && (y) % 100 != 0) || (y) % 400 == 0)
  357. #define nleap(y) (((y) - 1969) / 4 - ((y) - 1901) / 100 + ((y) - 1601) / 400)
  358.  
  359.     static char month_lengths[] =
  360.         { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
  361.     int day_of_year, year;
  362. #ifndef    OLDC
  363.     struct utimbuf times;
  364. #else
  365.     struct utimbuf {
  366.         time_t actime;        /* file accessed time */
  367.         time_t modtime;        /* file updated time */
  368.     } times;
  369. #endif    /* OLDC */
  370.  
  371.     /*
  372.      * this is the standard Unix implementation (also fully
  373.      * compatible with MSC)
  374.      */
  375.  
  376.     close(outfd);
  377.     td.zt.ztime = lrec.last_mod_file_time;
  378.     td.zt.zdate = lrec.last_mod_file_date;
  379.     year = td.ft.ft_year + 1980;
  380.     if (td.ft.ft_month < 1 || td.ft.ft_month > 12 || td.ft.ft_day < 1
  381.         || td.ft.ft_day > month_lengths[td.ft.ft_month-1]
  382.         && !(td.ft.ft_month == 2 && td.ft.ft_day == 29 && leap (year))
  383.         || td.ft.ft_hour > 23 || td.ft.ft_min > 59 ||
  384.         td.ft.ft_tsec*2 > 59)
  385.         return;
  386.     day_of_year = td.ft.ft_day - 1;
  387.     if (td.ft.ft_month > 2 && leap(year)) ++day_of_year;
  388.     while (--td.ft.ft_month > 0)
  389.         day_of_year += month_lengths[td.ft.ft_month - 1];
  390.     times.modtime = (86400 * (long)(day_of_year + 365 * (year - 1970) 
  391.         + nleap (year)) + 3600 * (td.ft.ft_hour-1) + 60 * td.ft.ft_min
  392.         + td.ft.ft_tsec*2);
  393. #ifdef    HAVE_TZ
  394.     tzset();
  395.     times.modtime += timezone;
  396. #endif    /* HAVE_TZ */
  397.     times.actime = times.modtime;
  398.     utime(filename, ×);
  399. #endif    /* !TURBOC */
  400. }
  401.  
  402.  
  403. int create_output_file(VOIDARG)
  404.  /* return non-0 if creat failed */
  405. {
  406.     /* create the output file with READ and WRITE permissions */
  407.     outfd = creat(filename, S_IWRITE | S_IREAD | S_IREAD >> 3
  408.             | S_IREAD >> 6);
  409.     if (outfd < 1) {
  410.         printf("Can't create output: %s\n", filename);
  411.         return 1;
  412.     }
  413.  
  414.     /*
  415.      * close the newly created file and reopen it in BINARY mode to
  416.      * disable all CR/LF translations 
  417.      */
  418.     close(outfd);
  419.     outfd = open(filename, O_RDWR | O_BINARY);
  420.  
  421.     /* write a single byte at EOF to pre-allocate the file */
  422. #ifdef    tx
  423.     fsetsize(outfd, lrec.uncompressed_size);
  424. #endif    /* tx */
  425.         lseek(outfd, lrec.uncompressed_size - 1L, SEEK_SET);
  426.     write(outfd, "?", 1);
  427.     lseek(outfd, 0L, SEEK_SET);
  428.     return 0;
  429. }
  430.  
  431.  
  432. int open_input_file(VOIDARG)
  433.  /* return non-0 if creat failed */
  434. {
  435.     /*
  436.      * open the zipfile for reading and in BINARY mode to prevent cr/lf
  437.      * translation, which would corrupt the bitstreams 
  438.      */
  439.  
  440.     zipfd = open(zipfn, O_RDONLY | O_BINARY);
  441.     if (zipfd < 1) {
  442.         printf("Can't open input file: %s\n", zipfn);
  443.         return (1);
  444.     }
  445.     return 0;
  446. }
  447.  
  448.  
  449. #ifdef HIGH_LOW
  450.  
  451. #ifndef    OLDC
  452. void swap_bytes(word *wordp)
  453. #else
  454. void swap_bytes(wordp)
  455. word *wordp;
  456. #endif    /* OLDC */
  457.  /* convert intel style 'short int' variable to host format */
  458. {
  459.     char *charp = (char *) wordp;
  460.     char temp[2];
  461.  
  462.     temp[0] = charp[w0];
  463.     temp[1] = charp[w1];
  464.     charp[0] = temp[0];
  465.     charp[1] = temp[1];
  466. }
  467.  
  468. #ifndef    OLDC
  469. void swap_lbytes(longint *longp)
  470. #else
  471. void swap_lbytes(longp)
  472. longint *longp;
  473. #endif    /* OLDC */
  474.  /* convert intel style 'long' variable to host format */
  475. {
  476.     char *charp = (char *) longp;
  477.     char temp[4];
  478.  
  479.     temp[0] = charp[li0];
  480.     temp[1] = charp[li1];
  481.     temp[2] = charp[li2];
  482.     temp[3] = charp[li3];
  483.     charp[0] = temp[0];
  484.     charp[1] = temp[1];
  485.     charp[2] = temp[2];
  486.     charp[3] = temp[3];
  487. }
  488.  
  489. #endif    /* HIGH_LOW */
  490.  
  491.  
  492.  
  493. /* ============================================================= */
  494.  
  495. int FillBuffer(VOIDARG)
  496.  /* fill input buffer if possible */
  497. {
  498.     int readsize;
  499.  
  500.         if (lrec.compressed_size <= 0)
  501.         return incnt = 0;
  502.  
  503.         if (lrec.compressed_size > INBUFSIZ)
  504.         readsize = INBUFSIZ;
  505.     else
  506.                 readsize = (int) lrec.compressed_size;
  507.     incnt = read(zipfd, inbuf, readsize);
  508.  
  509.         lrec.compressed_size -= incnt;
  510.     inptr = inbuf;
  511.     return incnt--;
  512. }
  513.  
  514. #ifndef    OLDC
  515. int ReadByte(unsigned *x)
  516. #else
  517. int ReadByte(x)
  518. unsigned *x;
  519. #endif    /* OLDC */
  520.  /* read a byte; return 8 if byte available, 0 if not */
  521. {
  522.     if (incnt-- == 0)
  523.         if (FillBuffer() == 0)
  524.             return 0;
  525.  
  526.     *x = *inptr++;
  527.     return 8;
  528. }
  529.  
  530.  
  531. /* ------------------------------------------------------------- */
  532. static unsigned mask_bits[] =
  533.         {0,     0x0001, 0x0003, 0x0007, 0x000f,
  534.                 0x001f, 0x003f, 0x007f, 0x00ff,
  535.                 0x01ff, 0x03ff, 0x07ff, 0x0fff,
  536.                 0x1fff, 0x3fff, 0x7fff, 0xffff
  537.         };
  538.  
  539.  
  540. #ifndef    OLDC
  541. int FillBitBuffer(register int bits)
  542. #else
  543. int FillBitBuffer(bits)
  544. register int bits;
  545. #endif    /* OLDC */
  546.  /* read a byte; return 8 if byte available, 0 if not */
  547. {
  548.     /* get the bits that are left and read the next word */
  549.     unsigned temp;
  550.         register int result = bitbuf;
  551.     int sbits = bits_left;
  552.     bits -= bits_left;
  553.  
  554.     /* read next word of input */
  555.     bits_left = ReadByte(&bitbuf);
  556.     bits_left += ReadByte(&temp);
  557.     bitbuf |= (temp << 8);
  558.     if (bits_left == 0)
  559.         zipeof = 1;
  560.  
  561.     /* get the remaining bits */
  562.         result = result | (int) ((bitbuf & mask_bits[bits]) << sbits);
  563.         bitbuf >>= bits;
  564.         bits_left -= bits;
  565.         return result;
  566. }
  567.  
  568. #define READBIT(nbits,zdest,ztype) \
  569.     { if (nbits <= bits_left) \
  570.         { zdest = ztype(bitbuf & mask_bits[nbits]); \
  571.         bitbuf >>= nbits; bits_left -= nbits; } \
  572.     else zdest = ztype(FillBitBuffer(nbits));}
  573.  
  574. /*
  575.  * macro READBIT(nbits,zdest,ztype)
  576.  *  {
  577.  *      if (nbits <= bits_left) {
  578.  *          zdest = ztype(bitbuf & mask_bits[nbits]);
  579.  *          bitbuf >>= nbits;
  580.  *          bits_left -= nbits;
  581.  *      } else
  582.  *          zdest = ztype(FillBitBuffer(nbits));
  583.  *  }
  584.  *
  585.  */
  586.  
  587.  
  588. /* ------------------------------------------------------------- */
  589.  
  590. #include "crc32.h"
  591.  
  592.  
  593. /* ------------------------------------------------------------- */
  594.  
  595. void FlushOutput(VOIDARG)
  596.  /* flush contents of output buffer */
  597. {
  598.     UpdateCRC(outbuf, outcnt);
  599.     write(outfd, outbuf, outcnt);
  600.     outpos += outcnt;
  601.     outcnt = 0;
  602.     outptr = outbuf;
  603. }
  604.  
  605. #define OUTB(intc) { *outptr++=intc; if (++outcnt==OUTBUFSIZ) FlushOutput(); }
  606.  
  607. /*
  608.  *  macro OUTB(intc)
  609.  *  {
  610.  *      *outptr++=intc;
  611.  *      if (++outcnt==OUTBUFSIZ)
  612.  *          FlushOutput();
  613.  *  }
  614.  *
  615.  */
  616.  
  617.  
  618. /* ----------------------------------------------------------- */
  619.  
  620. void LoadFollowers(VOIDARG)
  621. {
  622.         register int x;
  623.         register int i;
  624.  
  625.     for (x = 255; x >= 0; x--) {
  626.                 READBIT(6,Slen[x],(byte));
  627.         for (i = 0; i < Slen[x]; i++) {
  628.                         READBIT(8,followers[x][i],(byte));
  629.         }
  630.     }
  631. }
  632.  
  633.  
  634. /* ----------------------------------------------------------- */
  635. /*
  636.  * The Reducing algorithm is actually a combination of two
  637.  * distinct algorithms.  The first algorithm compresses repeated
  638.  * byte sequences, and the second algorithm takes the compressed
  639.  * stream from the first algorithm and applies a probabilistic
  640.  * compression method.
  641.  */
  642.  
  643. int L_table[] = {0, 0x7f, 0x3f, 0x1f, 0x0f};
  644.  
  645. int D_shift[] = {0, 0x07, 0x06, 0x05, 0x04};
  646. int D_mask[]  = {0, 0x01, 0x03, 0x07, 0x0f};
  647.  
  648. int B_table[] = {8, 1, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5,
  649.          5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6,
  650.          6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
  651.          6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7,
  652.          7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
  653.          7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
  654.          7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
  655.          7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  656.          8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  657.          8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  658.          8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  659.          8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  660.          8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  661.          8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  662.          8, 8, 8, 8};
  663.  
  664. /* ----------------------------------------------------------- */
  665.  
  666. void unReduce(VOIDARG)
  667.  /* expand probablisticly reduced data */
  668. {
  669.         register int lchar;
  670.         int nchar;
  671.         int ExState;
  672.         int V;
  673.         int Len;
  674.  
  675.         factor = lrec.compression_method - 1;
  676.     ExState = 0;
  677.     lchar = 0;
  678.     LoadFollowers();
  679.  
  680.         while (((outpos+outcnt) < lrec.uncompressed_size) && (!zipeof)) {
  681.         if (Slen[lchar] == 0)
  682.                         READBIT(8,nchar,(int))      /* ; */
  683.                 else
  684.         {
  685.                         READBIT(1,nchar,(int));
  686.                         if (nchar != 0)
  687.                                 READBIT(8,nchar,(int))      /* ; */
  688.                         else
  689.             {
  690.                                 int follower;
  691.                                 int bitsneeded = B_table[Slen[lchar]];
  692.                                 READBIT(bitsneeded,follower,(int));
  693.                                 nchar = followers[lchar][follower];
  694.             }
  695.         }
  696.  
  697.         /* expand the resulting byte */
  698.         switch (ExState) {
  699.  
  700.         case 0:
  701.                         if (nchar != DLE)
  702.                                 OUTB((byte) nchar) /*;*/
  703.             else
  704.                 ExState = 1;
  705.             break;
  706.  
  707.         case 1:
  708.                         if (nchar != 0) {
  709.                                 V = nchar;
  710.                 Len = V & L_table[factor];
  711.                 if (Len == L_table[factor])
  712.                     ExState = 2;
  713.                 else
  714.                     ExState = 3;
  715.             }
  716.             else {
  717.                                 OUTB(DLE);
  718.                 ExState = 0;
  719.             }
  720.             break;
  721.  
  722.                 case 2: {
  723.                                 Len += nchar;
  724.                 ExState = 3;
  725.             }
  726.             break;
  727.  
  728.                 case 3: {
  729.                 register int i = Len + 3;
  730.                 int offset = (((V >> D_shift[factor]) &
  731.                                           D_mask[factor]) << 8) + nchar + 1;
  732.                                 longint op = (outpos+outcnt) - offset;
  733.  
  734.                 /* special case- before start of file */
  735.                 while ((op < 0L) && (i > 0)) {
  736.                     OUTB(0);
  737.                     op++;
  738.                     i--;
  739.                 }
  740.  
  741.                 /* normal copy of data from output buffer */
  742.                 {
  743.                     register int ix = (int) (op % OUTBUFSIZ);
  744.  
  745.                                         /* do a block memory copy if possible */
  746.                                         if ( ((ix    +i) < OUTBUFSIZ) &&
  747.                                              ((outcnt+i) < OUTBUFSIZ) ) {
  748.                                                 memcpy(outptr,&outbuf[ix],i);
  749.                                                 outptr += i;
  750.                                                 outcnt += i;
  751.                                         }
  752.  
  753.                                         /* otherwise copy byte by byte */
  754.                                         else while (i--) {
  755.                                                 OUTB(outbuf[ix]);
  756.                                                 if (++ix >= OUTBUFSIZ)
  757.                                                         ix = 0;
  758.                                         }
  759.                                 }
  760.  
  761.                 ExState = 0;
  762.             }
  763.             break;
  764.         }
  765.  
  766.                 /* store character for next iteration */
  767.                 lchar = nchar;
  768.         }
  769. }
  770.  
  771.  
  772. /* ------------------------------------------------------------- */
  773. /*
  774.  * Shrinking is a Dynamic Ziv-Lempel-Welch compression algorithm
  775.  * with partial clearing.
  776.  *
  777.  */
  778.  
  779. void partial_clear(VOIDARG)
  780. {
  781.         register int pr;
  782.         register int cd;
  783.  
  784.     /* mark all nodes as potentially unused */
  785.     for (cd = first_ent; cd < free_ent; cd++)
  786.         prefix_of[cd] |= 0x8000;
  787.  
  788.     /* unmark those that are used by other nodes */
  789.     for (cd = first_ent; cd < free_ent; cd++) {
  790.         pr = prefix_of[cd] & 0x7fff;    /* reference to another node? */
  791.                 if (pr >= first_ent)            /* flag node as referenced */
  792.             prefix_of[pr] &= 0x7fff;
  793.     }
  794.  
  795.     /* clear the ones that are still marked */
  796.     for (cd = first_ent; cd < free_ent; cd++)
  797.         if ((prefix_of[cd] & 0x8000) != 0)
  798.             prefix_of[cd] = -1;
  799.  
  800.     /* find first cleared node as next free_ent */
  801.         cd = first_ent;
  802.         while ((cd < maxcodemax) && (prefix_of[cd] != -1))
  803.                 cd++;
  804.         free_ent = cd;
  805. }
  806.  
  807.  
  808. /* ------------------------------------------------------------- */
  809.  
  810. void unShrink(VOIDARG)
  811. {
  812. #define  GetCode(dest) READBIT(codesize,dest,(int))
  813.  
  814.     register int code;
  815.     register int stackp;
  816.     int finchar;
  817.     int oldcode;
  818.     int incode;
  819.  
  820.  
  821.     /* decompress the file */
  822.     maxcodemax = 1 << max_bits;
  823.     codesize = init_bits;
  824.     maxcode = (1 << codesize) - 1;
  825.     free_ent = first_ent;
  826.     offset = 0;
  827.     sizex = 0;
  828.  
  829.     for (code = maxcodemax; code > 255; code--)
  830.         prefix_of[code] = -1;
  831.  
  832.     for (code = 255; code >= 0; code--) {
  833.         prefix_of[code] = 0;
  834.         suffix_of[code] = (byte) code;
  835.     }
  836.  
  837.     GetCode(oldcode);
  838.     if (zipeof)
  839.         return;
  840.     finchar = oldcode;
  841.  
  842.         OUTB((byte) finchar);
  843.  
  844.         stackp = hsize;
  845.  
  846.     while (!zipeof) {
  847.         GetCode(code);
  848.         if (zipeof)
  849.             return;
  850.  
  851.         while (code == clear) {
  852.             GetCode(code);
  853.             switch (code) {
  854.  
  855.             case 1:{
  856.                     codesize++;
  857.                     if (codesize == max_bits)
  858.                         maxcode = maxcodemax;
  859.                     else
  860.                         maxcode = (1 << codesize) - 1;
  861.                 }
  862.                 break;
  863.  
  864.             case 2:
  865.                 partial_clear();
  866.                 break;
  867.             }
  868.  
  869.             GetCode(code);
  870.             if (zipeof)
  871.                 return;
  872.         }
  873.  
  874.  
  875.         /* special case for KwKwK string */
  876.         incode = code;
  877.         if (prefix_of[code] == -1) {
  878.                         stack[--stackp] = (byte) finchar;
  879.             code = oldcode;
  880.         }
  881.  
  882.  
  883.         /* generate output characters in reverse order */
  884.         while (code >= first_ent) {
  885.                         stack[--stackp] = suffix_of[code];
  886.             code = prefix_of[code];
  887.         }
  888.  
  889.         finchar = suffix_of[code];
  890.                 stack[--stackp] = (byte) finchar;
  891.  
  892.  
  893.                 /* and put them out in forward order, block copy */
  894.                 if ((hsize-stackp+outcnt) < OUTBUFSIZ) {
  895.                         memcpy(outptr,&stack[stackp],hsize-stackp);
  896.                         outptr += hsize-stackp;
  897.                         outcnt += hsize-stackp;
  898.                         stackp = hsize;
  899.                 }
  900.  
  901.                 /* output byte by byte if we can't go by blocks */
  902.                 else while (stackp < hsize)
  903.                         OUTB(stack[stackp++]);
  904.  
  905.  
  906.         /* generate new entry */
  907.         code = free_ent;
  908.         if (code < maxcodemax) {
  909.             prefix_of[code] = oldcode;
  910.             suffix_of[code] = (byte) finchar;
  911.  
  912.             do
  913.                 code++;
  914.             while ((code < maxcodemax) && (prefix_of[code] != -1));
  915.  
  916.             free_ent = code;
  917.         }
  918.  
  919.         /* remember previous code */
  920.         oldcode = incode;
  921.     }
  922.  
  923. }
  924.  
  925.  
  926. /* ------------------------------------------------------------- */ 
  927. /*
  928.  * Imploding
  929.  * ---------
  930.  *
  931.  * The Imploding algorithm is actually a combination of two distinct
  932.  * algorithms.  The first algorithm compresses repeated byte sequences
  933.  * using a sliding dictionary.  The second algorithm is used to compress
  934.  * the encoding of the sliding dictionary ouput, using multiple
  935.  * Shannon-Fano trees.
  936.  *
  937.  */ 
  938.  
  939. #define maxSF 256
  940.  
  941.    typedef struct sf_entry { 
  942.                  word         Code; 
  943.                  byte         Value; 
  944.                  byte         BitLength; 
  945.               } sf_entry; 
  946.  
  947.    typedef struct sf_tree {   /* a shannon-fano tree */ 
  948.       sf_entry     entry[maxSF];
  949.       int          entries;
  950.       int          MaxLength;
  951.    } sf_tree; 
  952.  
  953.    typedef sf_tree      *sf_treep; 
  954.  
  955.    sf_tree      lit_tree; 
  956.    sf_tree      length_tree; 
  957.    sf_tree      distance_tree; 
  958.    boolean      lit_tree_present; 
  959.    boolean      eightK_dictionary; 
  960.    int          minimum_match_length;
  961.    int          dict_bits;
  962.  
  963.  
  964. #ifndef    OLDC
  965. void SortLengths(sf_tree *tree)
  966. #else
  967. void SortLengths(tree)
  968. sf_tree *tree;
  969. #endif    /* OLDC */
  970.   /* Sort the Bit Lengths in ascending order, while retaining the order
  971.     of the original lengths stored in the file */ 
  972. { 
  973.    int          x;
  974.    int          gap;
  975.    sf_entry     t; 
  976.    boolean      noswaps;
  977.    int          a, b;
  978.  
  979.    gap = tree->entries / 2; 
  980.  
  981.    do { 
  982.       do { 
  983.          noswaps = 1;
  984.          for (x = 0; x <= (tree->entries - 1) - gap; x++) 
  985.          { 
  986.             a = tree->entry[x].BitLength; 
  987.             b = tree->entry[x + gap].BitLength; 
  988.             if ((a > b) || ((a == b) && (tree->entry[x].Value > tree->entry[x + gap].Value))) 
  989.             { 
  990.                t = tree->entry[x]; 
  991.                tree->entry[x] = tree->entry[x + gap]; 
  992.                tree->entry[x + gap] = t; 
  993.                noswaps = 0;
  994.             } 
  995.          } 
  996.       }  while (!noswaps);
  997.  
  998.       gap = gap / 2; 
  999.    }  while (gap > 0);
  1000. } 
  1001.  
  1002.  
  1003. /* ----------------------------------------------------------- */ 
  1004.  
  1005. #ifndef    OLDC
  1006. void ReadLengths(sf_tree *tree)
  1007. #else
  1008. void ReadLengths(tree)
  1009. sf_tree *tree;
  1010. #endif    /* OLDC */
  1011. { 
  1012.    int          treeBytes;
  1013.    int          i;
  1014.    int          num, len;
  1015.  
  1016.   /* get number of bytes in compressed tree */
  1017.    READBIT(8,treeBytes,(int));
  1018.    treeBytes++; 
  1019.    i = 0; 
  1020.  
  1021.    tree->MaxLength = 0;
  1022.  
  1023.  /* High 4 bits: Number of values at this bit length + 1. (1 - 16)
  1024.     Low  4 bits: Bit Length needed to represent value + 1. (1 - 16) */
  1025.    while (treeBytes > 0)
  1026.    {
  1027.       READBIT(4,len,(int)); len++;
  1028.       READBIT(4,num,(int)); num++;
  1029.  
  1030.       while (num > 0)
  1031.       {
  1032.          if (len > tree->MaxLength)
  1033.             tree->MaxLength = len;
  1034.          tree->entry[i].BitLength = (byte) len;
  1035.          tree->entry[i].Value = (byte) i;
  1036.          i++;
  1037.          num--;
  1038.       }
  1039.  
  1040.       treeBytes--;
  1041.    } 
  1042. } 
  1043.  
  1044.  
  1045. /* ----------------------------------------------------------- */ 
  1046.  
  1047. #ifndef    OLDC
  1048. void GenerateTrees(sf_tree *tree)
  1049. #else
  1050. void GenerateTrees(tree)
  1051. sf_tree *tree;
  1052. #endif    /* OLDC */
  1053.      /* Generate the Shannon-Fano trees */ 
  1054. { 
  1055.    word         Code;
  1056.    int          CodeIncrement;
  1057.    int          LastBitLength;
  1058.    int          i;
  1059.  
  1060.  
  1061.    Code = 0;
  1062.    CodeIncrement = 0; 
  1063.    LastBitLength = 0; 
  1064.  
  1065.    i = tree->entries - 1;   /* either 255 or 63 */ 
  1066.    while (i >= 0) 
  1067.    { 
  1068.       Code += CodeIncrement; 
  1069.       if (tree->entry[i].BitLength != (byte) LastBitLength) 
  1070.       { 
  1071.          LastBitLength = tree->entry[i].BitLength; 
  1072.          CodeIncrement = 1 << (16 - LastBitLength); 
  1073.       } 
  1074.  
  1075.       tree->entry[i].Code = Code; 
  1076.       i--; 
  1077.    } 
  1078. } 
  1079.  
  1080.  
  1081. /* ----------------------------------------------------------- */ 
  1082.  
  1083. #ifndef    OLDC
  1084. void ReverseBits(sf_tree *tree)
  1085. #else
  1086. void ReverseBits(tree)
  1087. sf_tree *tree;
  1088. #endif    /* OLDC */
  1089.  /* Reverse the order of all the bits in the above ShannonCode[]
  1090.     vector, so that the most significant bit becomes the least
  1091.     significant bit. For example, the value 0x1234 (hex) would become
  1092.     0x2C48 (hex). */ 
  1093. { 
  1094.    int          i;
  1095.    word         mask;
  1096.    word         revb;
  1097.    word         v;
  1098.    word         o;
  1099.    int          b;
  1100.  
  1101.  
  1102.    for (i = 0; i <= tree->entries - 1; i++) 
  1103.    { 
  1104.         /* get original code */ 
  1105.       o = tree->entry[i].Code; 
  1106.  
  1107.         /* reverse each bit */ 
  1108.       mask = 0x0001;
  1109.       revb = 0x8000;
  1110.       v = 0;
  1111.       for (b = 0; b <= 15; b++) 
  1112.       { 
  1113.            /* if bit set in mask, then substitute reversed bit */ 
  1114.          if ((o & mask) != 0) 
  1115.             v = v | revb; 
  1116.  
  1117.            /* advance to next bit */ 
  1118.          revb = (revb >> 1);
  1119.          mask = (mask << 1);
  1120.       } 
  1121.  
  1122.         /* store reversed bits */ 
  1123.       tree->entry[i].Code = v; 
  1124.    } 
  1125. } 
  1126.  
  1127.  
  1128. /* ----------------------------------------------------------- */ 
  1129.  
  1130. #ifndef    OLDC
  1131. void LoadTree(sf_tree *tree, int treesize)
  1132. #else
  1133. void LoadTree(tree, treesize)
  1134. sf_tree *tree;
  1135. int treesize;
  1136. #endif    /* OLDC */
  1137.      /* allocate and load a shannon-fano tree from the compressed file */ 
  1138. { 
  1139.    tree->entries = treesize; 
  1140.    ReadLengths(tree); 
  1141.    SortLengths(tree); 
  1142.    GenerateTrees(tree); 
  1143.    ReverseBits(tree); 
  1144. } 
  1145.  
  1146.  
  1147. /* ----------------------------------------------------------- */ 
  1148.  
  1149. #ifndef    OLDC
  1150. void LoadTrees(void)
  1151. #else
  1152. void LoadTrees()
  1153. #endif    /* OLDC */
  1154. { 
  1155.    /* bit 1... */
  1156.    eightK_dictionary = (boolean) ((lrec.general_purpose_bit_flag & 0x02) != 0);
  1157.    /* bit 2... */
  1158.    lit_tree_present = (boolean) ((lrec.general_purpose_bit_flag & 0x04) != 0);
  1159.  
  1160.    if (eightK_dictionary) 
  1161.       dict_bits = 7;
  1162.    else 
  1163.       dict_bits = 6; 
  1164.  
  1165.    if (lit_tree_present) 
  1166.    { 
  1167.       minimum_match_length = 3; 
  1168.       LoadTree(&lit_tree,256); 
  1169.    } 
  1170.    else 
  1171.       minimum_match_length = 2; 
  1172.  
  1173.    LoadTree(&length_tree,64); 
  1174.    LoadTree(&distance_tree,64); 
  1175. } 
  1176.  
  1177.  
  1178. /* ----------------------------------------------------------- */ 
  1179.  
  1180. #ifndef    OLDC
  1181. void ReadTree(sf_tree *tree, int *dest)
  1182. #else
  1183. void ReadTree(tree, dest)
  1184. sf_tree *tree;
  1185. int *dest;
  1186. #endif    /* OLDC */
  1187.      /* read next byte using a shannon-fano tree */ 
  1188. { 
  1189.    int          bits = 0;
  1190.    word         cv = 0;
  1191.    int          cur = 0;
  1192.    int          b;
  1193.  
  1194.    *dest = -1;   /* in case of error */ 
  1195.  
  1196.    for (;;)
  1197.    { 
  1198.       READBIT(1,b,(int));
  1199.       cv = cv | (b << bits);
  1200.       bits++; 
  1201.  
  1202.       /* this is a very poor way of decoding shannon-fano.  two quicker
  1203.          methods come to mind:
  1204.             a) arrange the tree as a huffman-style binary tree with
  1205.                a "leaf" indicator at each node,
  1206.          and
  1207.             b) take advantage of the fact that s-f codes are at most 8
  1208.                bits long and alias unused codes for all bits following
  1209.                the "leaf" bit.
  1210.       */
  1211.  
  1212.       while (tree->entry[cur].BitLength < (byte) bits) 
  1213.       { 
  1214.          cur++; 
  1215.          if (cur >= tree->entries) 
  1216.             return; /* data error */
  1217.       } 
  1218.  
  1219.       while (tree->entry[cur].BitLength == (byte) bits) 
  1220.       { 
  1221.          if (tree->entry[cur].Code == cv) 
  1222.          { 
  1223.             *dest = tree->entry[cur].Value; 
  1224.             return; 
  1225.          } 
  1226.  
  1227.          cur++; 
  1228.          if (cur >= tree->entries) 
  1229.             return; /* data error */
  1230.       } 
  1231.    } 
  1232. } 
  1233.  
  1234.  
  1235. /* ----------------------------------------------------------- */ 
  1236.  
  1237. #ifndef    OLDC
  1238. void unImplode(void)
  1239. #else
  1240. void unImplode()
  1241. #endif    /* OLDC */
  1242.      /* expand imploded data */ 
  1243.  
  1244. { 
  1245.    int          lout;
  1246.    longint      op;
  1247.    int          Length;
  1248.    int          Distance;
  1249.  
  1250.    LoadTrees(); 
  1251.  
  1252.    while ((!zipeof) && ((outpos+outcnt) < lrec.uncompressed_size))
  1253.    { 
  1254.       READBIT(1,lout,(int));
  1255.  
  1256.       if (lout != 0)   /* encoded data is literal data */ 
  1257.       { 
  1258.          if (lit_tree_present)  /* use Literal Shannon-Fano tree */
  1259.             ReadTree(&lit_tree,&lout);
  1260.          else 
  1261.             READBIT(8,lout,(int));
  1262.  
  1263.          OUTB((byte) lout);
  1264.       } 
  1265.       else             /* encoded data is sliding dictionary match */
  1266.       {                
  1267.          READBIT(dict_bits,lout,(int));
  1268.          Distance = lout; 
  1269.  
  1270.          ReadTree(&distance_tree,&lout); 
  1271.          Distance |= (lout << dict_bits);
  1272.          /* using the Distance Shannon-Fano tree, read and decode the
  1273.             upper 6 bits of the Distance value */ 
  1274.  
  1275.          ReadTree(&length_tree,&Length); 
  1276.          /* using the Length Shannon-Fano tree, read and decode the
  1277.             Length value */
  1278.  
  1279.          Length += minimum_match_length; 
  1280.          if (Length == (63 + minimum_match_length)) 
  1281.          { 
  1282.             READBIT(8,lout,(int));
  1283.             Length += lout; 
  1284.          } 
  1285.  
  1286.         /* move backwards Distance+1 bytes in the output stream, and copy
  1287.           Length characters from this position to the output stream.
  1288.           (if this position is before the start of the output stream,
  1289.           then assume that all the data before the start of the output
  1290.           stream is filled with zeros) */ 
  1291.  
  1292.          op = (outpos+outcnt) - Distance - 1L;
  1293.  
  1294.           /* special case- before start of file */
  1295.           while ((op < 0L) && (Length > 0)) {
  1296.                   OUTB(0);
  1297.                   op++;
  1298.                   Length--;
  1299.           }
  1300.  
  1301.           /* normal copy of data from output buffer */
  1302.           {
  1303.                   register int ix = (int) (op % OUTBUFSIZ);
  1304.  
  1305.                   /* do a block memory copy if possible */
  1306.                   if ( ((ix    +Length) < OUTBUFSIZ) &&
  1307.                        ((outcnt+Length) < OUTBUFSIZ) ) {
  1308.                           memcpy(outptr,&outbuf[ix],Length);
  1309.                           outptr += Length;
  1310.                           outcnt += Length;
  1311.                   }
  1312.  
  1313.                   /* otherwise copy byte by byte */
  1314.                   else while (Length--) {
  1315.                           OUTB(outbuf[ix]);
  1316.                           if (++ix >= OUTBUFSIZ)
  1317.                                   ix = 0;
  1318.                   }
  1319.          }
  1320.       } 
  1321.    } 
  1322. } 
  1323.  
  1324.  
  1325.  
  1326. /* ---------------------------------------------------------- */
  1327.  
  1328. void extract_member(VOIDARG)
  1329. {
  1330.         unsigned b;
  1331.  
  1332.     bits_left = 0;
  1333.     bitbuf = 0;
  1334.     incnt = 0;
  1335.     outpos = 0L;
  1336.     outcnt = 0;
  1337.     outptr = outbuf;
  1338.     zipeof = 0;
  1339.     crc32val = 0xFFFFFFFFL;
  1340.  
  1341.  
  1342.     /* create the output file with READ and WRITE permissions */
  1343.     if (create_output_file())
  1344.         exit(1);
  1345.  
  1346.         switch (lrec.compression_method) {
  1347.  
  1348.     case 0:        /* stored */
  1349.         {
  1350.             printf(" Extracting: %-12s ", filename);
  1351.             while (ReadByte(&b))
  1352.                 OUTB((byte) b);
  1353.         }
  1354.         break;
  1355.  
  1356.         case 1: {
  1357.             printf("UnShrinking: %-12s ", filename);
  1358.             unShrink();
  1359.         }
  1360.         break;
  1361.  
  1362.     case 2:
  1363.     case 3:
  1364.     case 4:
  1365.         case 5: {
  1366.             printf("  Expanding: %-12s ", filename);
  1367.             unReduce();
  1368.         }
  1369.         break;
  1370.  
  1371.         case 6: {
  1372.                         printf("  Exploding: %-12s ", filename);
  1373.                         unImplode();
  1374.         }
  1375.         break;
  1376.  
  1377.         default:
  1378.         printf("Unknown compression method.");
  1379.     }
  1380.  
  1381.  
  1382.     /* write the last partial buffer, if any */
  1383.     if (outcnt > 0) {
  1384.         UpdateCRC(outbuf, outcnt);
  1385.         write(outfd, outbuf, outcnt);
  1386.     }
  1387.  
  1388.     /* set output file date and time */
  1389.     set_file_time();
  1390.  
  1391.     close(outfd);
  1392.  
  1393.     crc32val = -1 - crc32val;
  1394.         if (crc32val != lrec.crc32)
  1395.                 printf(" Bad CRC %08lx  (should be %08lx)", lrec.crc32, crc32val);
  1396.  
  1397.     printf("\n");
  1398. }
  1399.  
  1400.  
  1401. /* ---------------------------------------------------------- */
  1402.  
  1403. #ifndef    OLDC
  1404. void get_string(int len, char *s)
  1405. #else
  1406. void get_string(len, s)
  1407. int len;
  1408. char *s;
  1409. #endif    /* OLDC */
  1410.  /* read a byte; return 8 if byte available, 0 if not */
  1411. {
  1412.     int len2;    /* J.E., Bug-fix for the case when string length > STRSIZ */
  1413.     len2 = len;                                     /* J.E. */
  1414.     if (len > STRSIZ) len = STRSIZ;                 /* J.E. */
  1415.     read(zipfd, s, len);
  1416.     s[len] = 0;
  1417.     lseek(zipfd, (long) (len2 - len), SEEK_CUR);    /* J.E. */
  1418. }
  1419.  
  1420.  
  1421. /* ---------------------------------------------------------- */
  1422.  
  1423. void process_local_file_header(VOIDARG)
  1424. {
  1425.     if ((long) &lrec.crc32 ==
  1426.             (long) &lrec.last_mod_file_date
  1427.             + sizeof(lrec.last_mod_file_date))
  1428.         read(zipfd, (char *) &lrec, sizeof(lrec));
  1429.     else {
  1430.         read(zipfd, (char *) &lrec, (unsigned)
  1431.             ((long) &lrec.last_mod_file_date
  1432.             + sizeof(lrec.last_mod_file_date)
  1433.             - (long) &lrec));
  1434.         read(zipfd, (char *) &lrec.crc32, (unsigned)
  1435.             ((long) &lrec.extra_field_length
  1436.             + sizeof(lrec.extra_field_length)
  1437.             - (long) &lrec.crc32));
  1438.     }
  1439.  
  1440. #ifdef HIGH_LOW
  1441.     swap_bytes(&lrec.version_needed_to_extract);
  1442.     swap_bytes(&lrec.general_purpose_bit_flag);
  1443.     swap_bytes(&lrec.compression_method);
  1444.     swap_bytes(&lrec.last_mod_file_time);
  1445.     swap_bytes(&lrec.last_mod_file_date);
  1446.     swap_lbytes(&lrec.crc32);
  1447.     swap_lbytes(&lrec.compressed_size);
  1448.     swap_lbytes(&lrec.uncompressed_size);
  1449.     swap_bytes(&lrec.filename_length);
  1450.     swap_bytes(&lrec.extra_field_length);
  1451. #endif    /* HIGH_LOW */
  1452.  
  1453.     get_string(lrec.filename_length, filename);
  1454.     get_string(lrec.extra_field_length, extra);
  1455. #ifdef    unix
  1456.     {
  1457.         char *cp;
  1458.         for (cp = filename; *cp; ++cp)
  1459.             if (isupper(*cp)) *cp = tolower(*cp);
  1460.     }
  1461. #endif    /* unix */
  1462.     extract_member();
  1463. }
  1464.  
  1465.  
  1466. /* ---------------------------------------------------------- */
  1467.  
  1468. void process_central_file_header(VOIDARG)
  1469. {
  1470.     central_directory_file_header rec;
  1471.     char filename[STRSIZ];
  1472.     char extra[STRSIZ];
  1473.     char comment[STRSIZ];
  1474.  
  1475.     if ((long) &rec.external_file_attributes ==
  1476.             (long) &rec.internal_file_attributes
  1477.             + sizeof(rec.internal_file_attributes))
  1478.         read(zipfd, (char *) &rec, sizeof(rec));
  1479.     else {
  1480.         read(zipfd, (char *) &rec, (unsigned)
  1481.             ((long) &rec.internal_file_attributes
  1482.             + sizeof(rec.internal_file_attributes)
  1483.             - (long) &rec));
  1484.         read(zipfd, (char *) &rec.external_file_attributes, (unsigned)
  1485.             ((long) &rec.relative_offset_local_header
  1486.             + sizeof(rec.relative_offset_local_header)
  1487.             - (long) &rec.external_file_attributes));
  1488.     }
  1489.  
  1490. #ifdef HIGH_LOW
  1491.     swap_bytes(&rec.version_made_by);
  1492.     swap_bytes(&rec.version_needed_to_extract);
  1493.     swap_bytes(&rec.general_purpose_bit_flag);
  1494.     swap_bytes(&rec.compression_method);
  1495.     swap_bytes(&rec.last_mod_file_time);
  1496.     swap_bytes(&rec.last_mod_file_date);
  1497.     swap_lbytes(&rec.crc32);
  1498.     swap_lbytes(&rec.compressed_size);
  1499.     swap_lbytes(&rec.uncompressed_size);
  1500.     swap_bytes(&rec.filename_length);
  1501.     swap_bytes(&rec.extra_field_length);
  1502.     swap_bytes(&rec.file_comment_length);
  1503.     swap_bytes(&rec.disk_number_start);
  1504.     swap_bytes(&rec.internal_file_attributes);
  1505.     swap_lbytes(&rec.external_file_attributes);
  1506.     swap_lbytes(&rec.relative_offset_local_header);
  1507. #endif    /* HIGH_LOW */
  1508.  
  1509.         get_string(rec.filename_length, filename);
  1510.     get_string(rec.extra_field_length, extra);
  1511.     get_string(rec.file_comment_length, comment);
  1512. #ifdef    unix
  1513.     {
  1514.         char *cp;
  1515.         for (cp = filename; *cp; ++cp)
  1516.             if (isupper(*cp)) *cp = tolower(*cp);
  1517.     }
  1518. #endif    /* unix */
  1519. }
  1520.  
  1521.  
  1522. /* ---------------------------------------------------------- */
  1523.  
  1524. void process_end_central_dir(VOIDARG)
  1525. {
  1526.     end_central_dir_record rec;
  1527.     char comment[STRSIZ];
  1528.  
  1529.     read(zipfd, (char *) &rec, sizeof(rec));
  1530.  
  1531. #ifdef HIGH_LOW
  1532.     swap_bytes(&rec.number_this_disk);
  1533. #ifndef    TURBOC
  1534.     swap_bytes(&rec.num_disk_with_start_cent_dir);
  1535.     swap_bytes(&rec.tot_ents_cent_dir_on_this_disk);
  1536. #else
  1537.     swap_bytes(&rec.number_disk_with_start_central_directory);
  1538.     swap_bytes(&rec.total_entries_central_dir_on_this_disk);
  1539. #endif    /* TURBOC */
  1540.     swap_bytes(&rec.total_entries_central_dir);
  1541.     swap_lbytes(&rec.size_central_directory);
  1542.     swap_lbytes(&rec.offset_start_central_directory);
  1543.     swap_bytes(&rec.zipfile_comment_length);
  1544. #endif    /* HIGH_LOW */
  1545.  
  1546.     get_string(rec.zipfile_comment_length, comment);
  1547. }
  1548.  
  1549.  
  1550. /* ---------------------------------------------------------- */
  1551.  
  1552. void process_headers(VOIDARG)
  1553. {
  1554.     longint sig;
  1555.  
  1556.     while (1) {
  1557.         if (read(zipfd, (char *) &sig, sizeof(sig)) != sizeof(sig))
  1558.             return;
  1559.  
  1560. #ifdef HIGH_LOW
  1561.         swap_lbytes(&sig);
  1562. #endif    /* HIGH_LOW */
  1563.  
  1564.                 if (sig == LOCAL_FILE_HEADER_SIGNATURE)
  1565.             process_local_file_header();
  1566.                 else if (sig == CENTRAL_FILE_HEADER_SIGNATURE)
  1567.             process_central_file_header();
  1568.                 else if (sig == END_CENTRAL_DIR_SIGNATURE) {
  1569.             process_end_central_dir();
  1570.             return;
  1571.         }
  1572.                 else {
  1573.             printf("Invalid Zipfile Header (0x%.8lx)\n", sig);
  1574.             return;
  1575.         }
  1576.     }
  1577.  
  1578. }
  1579.  
  1580.  
  1581. /* ---------------------------------------------------------- */
  1582.  
  1583. void extract_zipfile(VOIDARG)
  1584. {
  1585.     /*
  1586.      * open the zipfile for reading and in BINARY mode to prevent cr/lf
  1587.      * translation, which would corrupt the bitstreams 
  1588.      */
  1589.  
  1590.     if (open_input_file())
  1591.         exit(1);
  1592.  
  1593. #ifdef HIGH_LOW
  1594.     {
  1595.         word w_sig;
  1596.         longint li_sig;
  1597.         char *bp, *bp0 = (char *)&li_sig, *bp3 = ((char *)&li_sig)+3;
  1598.  
  1599.         if (read(zipfd, (char *) &w_sig, 2) == 2)
  1600.             if (w_sig == (LOCAL_FILE_HEADER_SIGNATURE & 0xffff)) {
  1601.                 w0 = 0;
  1602.                 w1 = 1;
  1603.             } else {
  1604.                 w0 = 1;
  1605.                 w1 = 0;
  1606.             }
  1607.         lseek(zipfd, 0L, SEEK_SET);
  1608.         if (read(zipfd, (char *) &li_sig, 4) == 4)
  1609.             if (li_sig == LOCAL_FILE_HEADER_SIGNATURE) {
  1610.                 li0 = 0;
  1611.                 li1 = 1;
  1612.                 li2 = 2;
  1613.                 li3 = 3;
  1614.             } else {
  1615.                 li0 = li1 = li2 = li3 = 0;
  1616.                 for (bp = bp0; bp < bp3; ++bp, ++li0)
  1617.                     if (*bp < 0x4b && !(*bp & 0x01))
  1618.                         break;
  1619.                 for (bp = bp0; bp < bp3; ++bp, ++li1)
  1620.                     if (*bp < 0x4b && (*bp & 0x01))
  1621.                         break;
  1622.                 for (bp = bp0; bp < bp3; ++bp, ++li2)
  1623.                     if (*bp == ((LOCAL_FILE_HEADER_SIGNATURE
  1624.                             >> 8) & 0xffL))
  1625.                         break;
  1626.                 for (bp = bp0; bp < bp3; ++bp, ++li3)
  1627.                     if (*bp == (LOCAL_FILE_HEADER_SIGNATURE
  1628.                             & 0xffL))
  1629.                         break;
  1630.             }
  1631.         lseek(zipfd, 0L, SEEK_SET);
  1632.     }
  1633. #endif    /* HIGH_LOW */
  1634.  
  1635.     process_headers();
  1636.  
  1637.     close(zipfd);
  1638. }
  1639.  
  1640.  
  1641. /* ---------------------------------------------------------- */
  1642. /*
  1643.  * main program
  1644.  *
  1645.  */
  1646.  
  1647. #ifndef    OLDC
  1648. void main(int argc, char **argv)
  1649. #else
  1650. void main(argc, argv)
  1651. int argc;
  1652. char **argv;
  1653. #endif    /* OLDC */
  1654.  /* read a byte; return 8 if byte available, 0 if not */
  1655. {
  1656.     MacInit(&argc, argv);    /* J.E., Provide command line arguments */
  1657.     if (argc != 2) {
  1658.                 printf("\n%s\nCourtesy of:  S.H.Smith  and  The Tool Shop BBS,  (602) 279-2673.\n\n",VERSION);
  1659.         printf("You may copy and distribute this program freely, provided that:\n");
  1660.         printf("    1)   No fee is charged for such copying and distribution, and\n");
  1661.         printf("    2)   It is distributed ONLY in its original, unmodified state.\n\n");
  1662.         printf("If you wish to distribute a modified version of this program, you MUST\n");
  1663.         printf("include the source code.\n\n");
  1664.         printf("If you modify this program, I would appreciate a copy of the  new source\n");
  1665.         printf("code.   I am holding the copyright on the source code, so please don't\n");
  1666.         printf("delete my name from the program files or from the documentation.\n\n");
  1667.                 printf("IN NO EVENT WILL I BE LIABLE TO YOU FOR ANY DAMAGES, INCLUDING ANY LOST\n");
  1668.                 printf("PROFITS, LOST SAVINGS OR OTHER INCIDENTAL OR CONSEQUENTIAL DAMAGES\n");
  1669.                 printf("ARISING OUT OF YOUR USE OR INABILITY TO USE THE PROGRAM, OR FOR ANY\n");
  1670.                 printf("CLAIM BY ANY OTHER PARTY.\n\n");
  1671.                 printf("Usage:  UnZip FILE[.zip]\n");
  1672.                 exit(1);
  1673.     }
  1674.  
  1675.     /* .ZIP default if none provided by user */
  1676.     strcpy(zipfn, argv[1]);
  1677.     if (strchr(zipfn, '.') == NULL)
  1678.         strcat(zipfn, ".zip");
  1679.  
  1680.         /* allocate i/o buffers */
  1681.     inbuf = (byte *) (malloc(INBUFSIZ));
  1682.     outbuf = (byte *) (malloc(OUTBUFSIZ));
  1683.     if ((inbuf == NULL) || (outbuf == NULL)) {
  1684.         printf("Can't allocate buffers!\n");
  1685.         exit(1);
  1686.     }
  1687.  
  1688.         /* do the job... */
  1689.         extract_zipfile();
  1690.     exit(0);
  1691. }
  1692.  
  1693. #include "MacUnZip.c"    /* J.E., Append special code for the Macintosh */